#include <iostream>
#include <string>
#include <cassert>
#include <typeinfo>
#include <typeindex>
#include <unistd.h>
#include<any>
using namespace std;

class Any{
    private:
    class holder{//父类
        public:
        //虚函数=0表示子类必须重写（实例化看对象）
        virtual ~holder(){}
        virtual  const std::type_info& type()=0;//返回数据类型
        virtual holder* clone()=0;//对象指针
    };
    template<class T>
    class placeholder:public holder{//子类
    public:
    placeholder(const T&val):_val(val){}//构造
     
        virtual const std::type_info& type(){return typeid(T);}//返回子类数据类型
        virtual holder* clone(){return  new placeholder(_val);}//根据当前对象克隆出一个新的子类对象

        public:
        T _val;
    };
    holder* _content;//父类指针
    public:
    Any():_content(NULL){}
    template<class T>
    Any(const T&val):_content(new placeholder<T>(val)){}//用val构造一个子类对象
    Any(const Any&other):_content(other._content?_content->clone():NULL){}//拷贝构造：用Any对象构造
    ~Any(){delete _content;}

   Any &swap(Any&other)
   {
   std:: swap(_content,other._content);
    return *this;
   }

   template<class T>
   T*get()//获取数据地址
   {
    assert(typeid(T)==_content->type());
    return &((placeholder<T>*)_content)->_val;
    //holder是父类，父类没有val，因此强转为子类，_content是个地址加*，返回的是val的地址
   }
   template<class T>
   Any& operator=(const T&val)//赋值重载用val构造
   {
    Any(val).swap(*this);
    return *this;
   }

   Any &operator=(Any&other)//赋值重载用other对象构造
   {
    Any(other).swap(*this);
    return *this;
   }
   


};

class Test
{
    public:
Test(){cout<<"gouzao"<<endl;}
Test(const Test&other){
    cout<<"拷贝gouzao"<<endl;
}
~Test(){cout<<"xigou"<<endl;}


};

int main()
{

    std::any a;
    a=10;
    int *pa=std::any_cast<int>(&a);
    cout<<*pa<<endl;
    // Any a;
    // {
    // Test t;
    // a=t;
    // }
    // while(1)
    // {
    //     sleep(1);
    // }
    // a=10;
    // int *pa=a.get<int>();//获取数据地址解引用打印
    // cout<<*pa<<endl;
    // a=string("imhappy");
    // string* pb=a.get<string>();
    //  cout<<*pb<<endl;
    return 0;
}